///////////////////////////////////////////////////////////////////////////////
// Project: Hoyo Client Game
//
// hy_server_skill_data.cpp
// Created: 2013-7-30
// Author: Like Cheng
///////////////////////////////////////////////////////////////////////////////

#include "hy_server_skill_data.h"
#include "hy_common_system/hy_common_func.h"

/*
hy_server_skill_level_data::hy_server_skill_level_data()
{

}
hy_server_skill_level_data::~hy_server_skill_level_data()
{

}

int_vec	hy_server_skill_level_data::get_enemy_tag()
{
	int_vec iv;
	Json::Value jv = m_json_value["enemy_tag_pos"];
	for( uint i = 0u; i < jv.size(); i++ )
	{
		iv.push_back( jv[i].asInt() );
	}
	return iv;
}

int_vec	hy_server_skill_level_data::get_own_tag()
{
	int_vec iv;
	Json::Value jv = m_json_value["own_tag_pos"];
	for( uint i = 0u; i < jv.size(); i++ )
	{
		iv.push_back( jv[i].asInt() );
	}
	return iv;
}

int	hy_server_skill_level_data::get_tag_min_num()
{
	return get_json_int( m_json_value, "tag_min_num" );
}

int	hy_server_skill_level_data::get_tag_max_num()
{
	return get_json_int( m_json_value, "tag_max_num" );
}

int hy_server_skill_level_data::get_select_tag_type()
{
	return get_json_int( m_json_value, "select_tag_type" );
}


int	hy_server_skill_level_data::get_attack_tag_type()
{
	return get_json_int( m_json_value, "attack_tag_type" );
}

int	hy_server_skill_level_data::get_skill_effect_pre_id()
{
	return 1;
}
int hy_server_skill_level_data::get_skill_effect_ing_id()
{
	Json::Value &se = m_json_value["skill_effect"];
	if( !se.empty() )
	{
		return get_json_int( se, "effect_id_c" );
	}
	return 0;
}

int	hy_server_skill_level_data::get_skill_effect_after_id()
{
	Json::Value &se = m_json_value["skill_effect"];
	if( !se.empty() )
	{
		return get_json_int( se, "effect_id_a" );
	}
	return 0;
}

Json::Value	hy_server_skill_level_data::get_tag_effect_type()
{
	Json::Value jv = m_json_value["skill_effect"];

	return jv["tag_effect_type"];
}

Json::Value	hy_server_skill_level_data::get_effect_content_by_key( const char* key )
{
	if( !key )return Json::Value();

	Json::Value jv = m_json_value["skill_effect"];

	return jv[key];
}


void hy_server_skill_level_data::set_json_value( Json::Value& jv )
{
	m_json_value = jv;
}
*/
hy_server_skill_data::hy_server_skill_data()
{
	init();
}
hy_server_skill_data::~hy_server_skill_data()
{

}
bool hy_server_skill_data::init()
{
	m_id = 0;
	m_value.clear();
	return true;
}

float_vec hy_server_skill_data::get_param( int level )
{
	float_vec vf;

	int max_level = m_update_need_exp.size();

	int ml = m_update_param.size()/max_level;

	int pos = (level-1) * ml;
	if( pos < 0 )return vf;
	if( pos >= (int)(m_update_param.size()) )return vf;

	int j = 0;
	for( size_t i = pos; i < m_update_param.size(),j<ml; i++,j++ )
	{
		vf.push_back( m_update_param.at( i ) );
	}
	
	return vf;
}
void hy_server_skill_data::set_value( Json::Value& v )
{
	m_value = v;

	m_id = v["id"].asInt();
	m_name = v["name"].asString().c_str();
	m_type = v["type"].asInt();
	for( unsigned int i = 0u; i < v["update_need_exp"].size(); i++ )
	{
		m_update_need_exp.push_back( v["update_need_exp"][i].asInt() );
	}
	for( unsigned int i = 0u; i < v["update_param"].size(); i++ )
	{
		m_update_param.push_back( (float)v["update_param"][i].asDouble() );
	}
	m_update_need_level = v["update_need_level"].asInt();
	m_des = v["des"].asString().c_str();
	m_icon = v["icon"].asInt();
	m_select_target = v["select_target"].asInt();
	m_sid = v["sid"].asInt();
	m_trigger = v["trigger"].asInt();
}
/*
///////////////////////////////////////////////////////////////////////////////
//hy_server_monster_data::get_max_define
///////////////////////////////////////////////////////////////////////////////
float hy_server_monster_data::get_dodge()
{
	return (float)get_json_double( m_value, "dodge" );
}
///////////////////////////////////////////////////////////////////////////////
//hy_server_monster_data::get_max_define
///////////////////////////////////////////////////////////////////////////////
float hy_server_monster_data::get_crit()
{
	return (float)get_json_double( m_value, "crit" );
}
///////////////////////////////////////////////////////////////////////////////
//hy_server_monster_data::get_strength
///////////////////////////////////////////////////////////////////////////////
int	hy_server_monster_data::get_strength()
{
	return 10;
}
///////////////////////////////////////////////////////////////////////////////
//hy_server_monster_data::get_agile
///////////////////////////////////////////////////////////////////////////////
int	hy_server_monster_data::get_agile()
{
	return 10;
}
///////////////////////////////////////////////////////////////////////////////
//hy_server_monster_data::get_blood
///////////////////////////////////////////////////////////////////////////////
int	hy_server_monster_data::get_blood()
{
	return 10;
}
///////////////////////////////////////////////////////////////////////////////
//hy_server_monster_data::get_luck
///////////////////////////////////////////////////////////////////////////////
int	hy_server_monster_data::get_luck()
{
	return 10;
}
///////////////////////////////////////////////////////////////////////////////
//hy_server_monster_data::get_float_min
///////////////////////////////////////////////////////////////////////////////
int	hy_server_monster_data::get_float_min()
{
	return 0;
}
///////////////////////////////////////////////////////////////////////////////
//hy_server_monster_data::get_float_max
///////////////////////////////////////////////////////////////////////////////
int	hy_server_monster_data::get_float_max()
{
	return 0;
}
///////////////////////////////////////////////////////////////////////////////
//hy_server_monster_data::get_type
///////////////////////////////////////////////////////////////////////////////
int	hy_server_monster_data::get_type()
{
	return get_json_int( m_value, "type" );
}
///////////////////////////////////////////////////////////////////////////////
//hy_server_monster_data::get_model
///////////////////////////////////////////////////////////////////////////////
int	hy_server_monster_data::get_model()
{
	return get_json_int( m_value, "model" );
}
*/

///////////////////////////////////////////////////////////////////////////////
hy_server_skill_mgr* hy_server_skill_mgr_instance = NULL;
///////////////////////////////////////////////////////////////////////////////
//hy_server_monster_mgr::hy_server_monster_mgr
///////////////////////////////////////////////////////////////////////////////
hy_server_skill_mgr::hy_server_skill_mgr()
{

}
///////////////////////////////////////////////////////////////////////////////
//hy_server_skill_mgr::~hy_server_skill_mgr
///////////////////////////////////////////////////////////////////////////////
hy_server_skill_mgr::~hy_server_skill_mgr()
{

}
///////////////////////////////////////////////////////////////////////////////
//hy_server_skill_mgr::instance
///////////////////////////////////////////////////////////////////////////////
hy_server_skill_mgr* hy_server_skill_mgr::instance()
{
	if( hy_server_skill_mgr_instance == NULL )
		hy_server_skill_mgr_instance = new hy_server_skill_mgr;
	return hy_server_skill_mgr_instance;
}
///////////////////////////////////////////////////////////////////////////////
//hy_server_skill_mgr::purge_instance
///////////////////////////////////////////////////////////////////////////////
void hy_server_skill_mgr::purge_instance()
{
	DEL_POINTER( hy_server_skill_mgr_instance );
}
///////////////////////////////////////////////////////////////////////////////
//hy_server_skill_mgr::add_server_skill_data
///////////////////////////////////////////////////////////////////////////////
bool hy_server_skill_mgr::add_server_skill_data( hy_server_skill_data* d , bool is_update )
{
	hy_server_skill_data_map::iterator it = m_server_skill_data_map.find( d->m_id );
	if( it != m_server_skill_data_map.end() )
	{
		if( is_update )
		{
			delete it->second;
			it->second = d;
			return true;
		}
	}
	else
	{
		m_server_skill_data_map.insert( std::make_pair( d->m_id, d ) );
	}
	return true;
}
///////////////////////////////////////////////////////////////////////////////
//hy_server_skill_mgr::get_server_monster_data
///////////////////////////////////////////////////////////////////////////////
hy_server_skill_data* hy_server_skill_mgr::get_server_skill_data( int id )
{
	hy_server_skill_data_map::iterator it = m_server_skill_data_map.find( id );
	if( it != m_server_skill_data_map.end() )
	{
		return it->second;
	}
	return NULL;
}